\indent Del an\'alisis anterior comprobamos que la implementaci\'on en ASM es mucho m\'as r\'apida que la implementaci\'on en C. Lo siguiente es ver que tanto influye el resto m\'odulo 16 en los tiempos de ejecuci\'on de nuestras implementaciones y si las implementaciones en ASM siguen mejorando su performance respecto a las de C. \\
Por que consideramos esta medici\'on importante?\\
Porque una de las consignas del enunciado es que el procesamiento de pixels debe hacerse exclusivamente con instrucciones SSE. Como cada registro SSE tiene una longitud de 16 bytes, en el caso ideal (1 byte = 1 pixel) si la imagen tiene un ancho que no es m\'ultiplo de 16, ese remanente de pixels tienen que ser procesador por instrucciones SSE. De que forma? \\
En todos los filtros lo que hicimos para esos casos fu\'e procesar los \'ultimos 16 pixels de la fila, los cuales incluir\'ian pixels ya procesados y por otro lado, aquellos remanentes producto de no ser m\'ultiplo de 16 el ancho de la fila.\\
\indent Como es de esperar, el reprocesado de pixels tiene cierta penalidad en la performance y en este apartado es eso lo que queremos estudiar. Aunque es necesario mencionar que dicha penalidad va a notarse fundamentalmente en las version Asm porque en C, al no haber paralelismo de procesamiento de pixels (mas all\'a de las implementaciones internas que el compilador pueda hacer, pero eso est\'a por fuera el alcance de este an\'alisis) el hecho de agregar pixels a la imagen, deber\'ia corresponderse con un aumento gradual en la cantidad de ticks del procesador.\\
Cabe destacar que como bien dijimos anteriormente no siempre podemos procesar 16 bytes por iteraci\'on (en ocasiones menos), de modo que cada filtro responder\'a distinto a los distinto anchos de fila. Por ejemplo, un ancho de fila resto 12 m\'odulo 16 tendr\'a que reprocesar 4 pixels para el filtro recortar pero ninguno para waves, p\'es este procesa de a 4 pixels y dicho ancho de fila es m\'ultiplo de 4.\\

\indent Tomamos una imagen de 1600x868 pixel en su versi\'on original, y editamos su tama\~no en valores que no sean m\'ultiplos de 16, con el objetivo de tener en cada imagen que reprocesar algunos pixels extra. \\


\indent A continuaci\'on mostramos los resultados obtenidos para cada filtro en una tabla comparativa. La primer columna corresponde a las dimensiones de la imagen, la segunda y tercera a los ciclos que toma la implementaci\'on en Asm y C. La cuarta y quinta columna corresponden a la diferencia de ciclos de ejecuci\'on entre la imagen original y la extensi\'on con el remanente, en un ejemplo seria; Ciclos(1605x868) - Ciclos(1600x868). \\


\subsubsection{Recortar}

\begin{center}
  \begin{tabular}{|c|c|c|c|c|}
    \hline
    \textbf{Tama\~no} & \textbf{ASM} & \textbf{C} & \textbf{Diferencia C} & \textbf{Diferencia ASM} \\
    \hline
    1600x868 & 62,463.762 & 2,101,460.375 & - & - \\
    1601x868 & 61,191.898 & 2,112,487.250 & + 21,027 ($+0.52\%$) & - 1,272 ($-2.08\%$) \\
    1605x868 & 58,462.053 & 2,106,427.000 & + 14,967 ($+0.23\%$) & - 4,001 ($-6.49\%$) \\
    1610x868 & 62,780.859 & 2,107107.750 & + 15,647 ($+0.21\%$) & - 317 ($+0.50\%$) \\
    1615x868 & 57,356.672 & 2,105,347.000 & + 13,887 ($+0.18 \%$) & - 5,107 ($-9.04\%$)\\
    \hline
  \end{tabular}
\end{center}

\indent Para este filtro en particular es esperable que el remanente no tenga influencia pues el tiempo de ejecuci\'on depende del recorte que se seleccione de la imagen. La diferencia alta en porcentaje se da pues el algoritmo calcula en pocos ciclos la imagen resultado, entonces al variar un poco el pocentaje parece mayor. El motivo de la diferencia es porque otros procesos estan usando el procesador al mismo momento que estamos haciendo las pruebas y eso afecta la cantidad total de ticks durante un per\'iodo de tiempo. Si bien tomamos un promedio de muchas corridas para suavizar outliers, es esperable cierta variaci\'on de ticks entre corridas.

\subsubsection{Halftone}

\begin{center}
  \begin{tabular}{|c|c|c|c|c|}
    \hline
    \textbf{Tama\~no} & \textbf{ASM} & \textbf{C} & \textbf{Diferencia C} & \textbf{Diferencia ASM}  \\
    \hline
    1600x868 & 48,918,694,024 & 2,577,739,808 & - & - \\
    1601x868 & 48,953,204,448 & 2,604,977,520 & + 34,510,424 ($+0.09\%$) & + 27,237,712 ($+1.09\%$)\\
    1605x868 & 49,036,857,336 & 2,611,752,624 & + 118,163,312 ($+0.34\%$) & + 34,012,816 ($+1.31\%$) \\
    1610x868 & 49,251,241,456 & 2,629,325,328 & + 332,547,432 ($+0.95\%$) & + 51,585,520 ($+2.00\%$)\\
    1615x868 & 49,215,503,320 & 2,635,217,384 & + 296,809,296 ($+0.85\%$) & + 57,477,576 ($+2.22\%$) \\
    \hline
  \end{tabular}
\end{center}


\subsubsection{Umbralizar}

\begin{center}
  \begin{tabular}{|c|c|c|c|c|}
    \hline
    \textbf{Tama\~no} & \textbf{ASM} & \textbf{C} & \textbf{Diferencia C} & \textbf{Diferencia ASM}  \\
    \hline
    1600x868 & 63,499,148,704 & 3,933,057,032 & - & - \\
    1601x868 & 63,502,229,240 & 3,951,628,176 & + 3,080,536 ($+0.005\%$) & + 18,571,144 ($+0.37\%$) \\
    1605x868 & 63,579,877,704 & 3,990,555,192 & + 80,729,000 ($+0.13\%$) & + 57,498,160 ($+1.16\%$) \\
    1610x868 & 63,761,019,896 & 4,029,970,608 & + 261,871,192 ($+0.44\%$) & + 96,913,576 ($+1.96\%$) \\
    1615x868 & 63,874,004,272 & 4,149,681,432 & + 374,855,568 ($+0.64\%$) & + 216,624,400 ($+4.39 \%$) \\
    \hline
  \end{tabular}
\end{center}


\subsubsection{Colorizar}

\begin{center}
  \begin{tabular}{|c|c|c|c|c|}
    \hline
    \textbf{Tama\~no} & \textbf{ASM} & \textbf{C} & \textbf{Diferencia C} & \textbf{Diferencia ASM}  \\
    \hline
    1600x868 & 90,334,752.000 & 1,153,051,776.000 & - & - \\
    1601x868 & 91,064,560.000 & 1,159,959,296.000 & +6,907,520($+0.59\%$) & +729,808 ($+0.80\%$) \\
    1605x868 & 91,243,864.000 & 1,162,814,848.000 & +9,763,072($+0.84\%$) & +909,112 ($+1.01\%$) \\
    1610x868 & 91,121,960.000 & 1,160,692,224.000 & +7,640,448($+0.66\%$) & +787,208 ($+0.87\%$) \\
    1615x868 & 9,1083,512.000 & 1,167,586,560.000 & +14,534,784($+1.26\%$) & +748,760 ($+0.82\%$) \\
    \hline
  \end{tabular}
\end{center}


\subsubsection{Plasma}

\begin{center}
  \begin{tabular}{|c|c|c|c|c|}
    \hline
    \textbf{Tama\~no} & \textbf{ASM} & \textbf{C} & \textbf{Diferencia C} & \textbf{Diferencia ASM}  \\
    \hline
    1600x868 & 66,756,352.000 & 2,942,036,992.000 & - & - \\
    1601x868 & 67,537,256.000 & 2,937,268,736.000 & + 1,379,256 ($+0.003\%$) & + 780,904 ($+1.16\%$) \\
    1605x868 & 67,516,112.000 & 2,949,087,232.000 & + 10,808,208 ($+0.28\%$) & + 759,760 ($+1.12\%$) \\
    1610x868 & 67,596,184.000 & 2,952,914,176,048.000 & + 191,397,752 ($+0.49\%$) & + 839,832 ($+1.24\%$) \\
    1615x868 & 67,465,536.000 & 2,958,496,512.000 & + 317,033,664 ($+0.82\%$) & + 709,184 ($+1.04\%$) \\
    \hline
  \end{tabular}
\end{center}


\subsubsection{Rotar}

\begin{center}
  \begin{tabular}{|c|c|c|c|c|}
    \hline
    \textbf{Tama\~no} & \textbf{ASM} & \textbf{C} & \textbf{Diferencia C} & \textbf{Diferencia ASM}  \\
    \hline
    1600x868 & 71,510,336,416 & 5,236,451,088 & - & - \\
    1601x868 & 71,569,594,752 & 5,282,531,048 & - 4,768,256 ($-0.16\%$) & + 46,079,960  ($+0.87\%$) \\
    1605x868 & 71,587,347,416 & 5,324,089,456 & + 7,050,240 ($+0.24\%$) & + 87,638,368 ($+1.67\%$) \\
    1610x868 & 71,951,226,800 & 5,294,218,576 & + 10,877,184 ($+0.36\%$) & + 57,767,488 ($+1.10\%$) \\
    1615x868 & 72,209,558,584 & 5,328,736,480 & + 16,459,520 ($+0.55\%$) & + 92,285,392 ($+1.76\%$) \\
    \hline
  \end{tabular}
\end{center}


\subsubsection{Conclusiones sobre el resto m\'odulo 16 (de ahora en mas lo llamamos remanente)}

\indent Exceptuando el filtro Recortar, donde el excedente no tiene efecto alguno (porque siempre se empieza a contar desde la \'ultima columna hacia atr\'as), en todos los otros filtros hubo una variaci\'on en los ciclos de ejecuci\'on en concordancia con lo que dijimos ser\'ian los resultados esperados en la secc\'on 3.7.  \\

\indent Por lo visto en las tablas las implementaciones en C consumen mucho mas ciclos que las de ASM y esta diferencia se evidencia mas a im\'agenes de mas pixeles.

\indent Se puede notar que las corridas en C tiene un porcentaje menor de incremento en ticks respecto a las de Asm. Esto se debe a dos razones principalmente:\\
\begin{itemize}
	\item El algoritmo de C, a diferencia de Asm, procesa secuencialmente y no en paralelo, de modo que en presencia de remanente solo tiene que procesar esa cantidad extra de pixels. O sea, si hay un remanente de 1 pixel por fila, solo tendr\'a que procesar un pixel mas por fila y no los ultimos 16 (con en Asm), eso explica el por que de el incremento gradual de porcentaje conforme a mayor remanente se debe a que simplemente el algoritmo en C tiene que procesar mas pixels.\\
	\item Por otro lado, las implementaciones en C tienen una cantidad de ticks promedio por corrida muy superior a los de Asm, de modo que el incremento se diluye frente al costo total de aplicar el filtro.
\end{itemize}



\indent Como dijimos anteriormente, el remanente implica un re-procesamiento de una cierta cantidad de bytes, alcanzando su m\'axima expresi\'on en aquellas im\'agenes donde el remanente sea 1. Tambi\'en es necesario mencionar que el re-procesado de pixels tiene mayor coste de penalidad en casos donde el procesamiento de cada pixel demande mas operaciones aritm\'eticas.\\

